
// 云函数入口文件
const cloud = require('wx-server-sdk')

cloud.init({
  env: cloud.DYNAMIC_CURRENT_ENV
})

const db = cloud.database()
const _ = db.command
const tagsCollection = db.collection('tags')

// 默认标签列表
const DEFAULT_TAGS = [
  { name: '工作', color: '#4A90E2', isDefault: true },
  { name: '生活', color: '#50B347', isDefault: true },
  { name: '学习', color: '#E6A23C', isDefault: true },
  { name: '重要', color: '#F56C6C', isDefault: true },
  { name: '紧急', color: '#FF5722', isDefault: true }
]

// 云函数入口函数
exports.main = async (event, context) => {
  const wxContext = cloud.getWXContext()
  const { type, data } = event

  // 确保用户已登录
  if (!wxContext.OPENID) {
    return {
      code: -1,
      msg: '用户未登录'
    }
  }

  switch (type) {
    case 'create':
      return await createTag(wxContext.OPENID, data)
    case 'update':
      return await updateTag(wxContext.OPENID, data)
    case 'delete':
      return await deleteTag(wxContext.OPENID, data)
    case 'list':
      return await listTags(wxContext.OPENID)
    case 'initDefaultTags':
      return await initDefaultTags(wxContext.OPENID)
    default:
      return {
        code: -1,
        msg: '未知的操作类型'
      }
  }
}

// 创建标签
async function createTag(openid, tagData) {
  try {
    // 检查标签名是否已存在
    const existingTag = await tagsCollection.where({
      userId: openid,
      name: tagData.name
    }).get()

    if (existingTag.data.length > 0) {
      return {
        code: -1,
        msg: '标签名称已存在'
      }
    }

    const data = {
      ...tagData,
      userId: openid,
      isDefault: false,
      createTime: db.serverDate(),
      updateTime: db.serverDate()
    }

    const result = await tagsCollection.add({
      data
    })

    return {
      code: 0,
      msg: '创建成功',
      data: {
        _id: result._id,
        ...data
      }
    }
  } catch (err) {
    console.error('[创建标签]失败：', err)
    return {
      code: -1,
      msg: '创建标签失败',
      error: err
    }
  }
}

// 更新标签
async function updateTag(openid, { _id, ...updateData }) {
  try {
    // 确保只能更新自己的标签
    const tag = await tagsCollection.doc(_id).get()
    if (!tag.data || tag.data.userId !== openid) {
      return {
        code: -1,
        msg: '无权限更新此标签'
      }
    }

    // 不允许更新默认标签
    if (tag.data.isDefault) {
      return {
        code: -1,
        msg: '不能修改默认标签'
      }
    }

    // 检查新名称是否与其他标签重复
    if (updateData.name) {
      const existingTag = await tagsCollection.where({
        userId: openid,
        name: updateData.name,
        _id: _.neq(_id)
      }).get()

      if (existingTag.data.length > 0) {
        return {
          code: -1,
          msg: '标签名称已存在'
        }
      }
    }

    const data = {
      ...updateData,
      updateTime: db.serverDate()
    }

    await tagsCollection.doc(_id).update({
      data
    })

    return {
      code: 0,
      msg: '更新成功',
      data: {
        _id,
        ...data
      }
    }
  } catch (err) {
    console.error('[更新标签]失败：', err)
    return {
      code: -1,
      msg: '更新标签失败',
      error: err
    }
  }
}

// 删除标签
async function deleteTag(openid, { _id }) {
  try {
    // 确保只能删除自己的标签
    const tag = await tagsCollection.doc(_id).get()
    if (!tag.data || tag.data.userId !== openid) {
      return {
        code: -1,
        msg: '无权限删除此标签'
      }
    }

    // 不允许删除默认标签
    if (tag.data.isDefault) {
      return {
        code: -1,
        msg: '不能删除默认标签'
      }
    }

    await tagsCollection.doc(_id).remove()

    return {
      code: 0,
      msg: '删除成功'
    }
  } catch (err) {
    console.error('[删除标签]失败：', err)
    return {
      code: -1,
      msg: '删除标签失败',
      error: err
    }
  }
}

// 查询标签列表
async function listTags(openid) {
  try {
    const tags = await tagsCollection
      .where({
        userId: openid
      })
      .orderBy('createTime', 'asc')
      .get()

    return {
      code: 0,
      msg: '查询成功',
      data: tags.data
    }
  } catch (err) {
    console.error('[查询标签列表]失败：', err)
    return {
      code: -1,
      msg: '查询标签列表失败',
      error: err
    }
  }
}

// 初始化默认标签
async function initDefaultTags(openid) {
  try {
    // 检查是否已经初始化过默认标签
    const existingTags = await tagsCollection.where({
      userId: openid,
      isDefault: true
    }).get()

    if (existingTags.data.length > 0) {
      return {
        code: 0,
        msg: '默认标签已存在'
      }
    }

    // 批量创建默认标签
    const defaultTags = DEFAULT_TAGS.map(tag => ({
      ...tag,
      userId: openid,
      createTime: db.serverDate(),
      updateTime: db.serverDate()
    }))

    await Promise.all(defaultTags.map(tag => 
      tagsCollection.add({ data: tag })
    ))

    return {
      code: 0,
      msg: '默认标签初始化成功',
      data: defaultTags
    }
  } catch (err) {
    console.error('[初始化默认标签]失败：', err)
    return {
      code: -1,
      msg: '初始化默认标签失败',
      error: err
    }
  }
}